home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / crt / sun4.md / mcount.xxx < prev    next >
Encoding:
Text File  |  1990-11-05  |  2.4 KB  |  110 lines
  1.  
  2. extern char profiling;
  3.  
  4. void
  5. __mcount(selfpc, frompcindex)
  6.     char *selfpc;
  7.     unsigned short *frompcindex;
  8. {
  9.     register struct tostruct    *top;    
  10.     register struct tostruct    *prevtop;
  11.     register long        toindex;
  12.  
  13.     /*
  14.      *    check that we are profiling
  15.      *    and that we aren't recursively invoked.
  16.      */
  17.     if (profiling) {
  18.     return;
  19.     }
  20.     profiling = 1;
  21.     /*
  22.      *    check that frompcindex is a reasonable pc value.
  23.      *    for example:    signal catchers get called from the stack,
  24.      *            not from text space.  too bad.
  25.      */
  26.     frompcindex = (unsigned short *)((long)frompcindex - (long)s_lowpc);
  27.     if ((unsigned long)frompcindex > s_textsize) {
  28.     goto done;
  29.     }
  30.     frompcindex = &froms[((long)frompcindex) / (HASHFRACTION * sizeof(*froms))];
  31.     toindex = *frompcindex;
  32.     if (toindex == 0) {
  33.     /*
  34.      *    first time traversing this arc
  35.      */
  36.     toindex = ++tos[0].link;
  37.     if (toindex >= tolimit) {
  38.         goto overflow;
  39.     }
  40.     *frompcindex = toindex;
  41.     top = &tos[toindex];
  42.     top->selfpc = selfpc;
  43.     top->count = 1;
  44.     top->link = 0;
  45.     goto done;
  46.     }
  47.     top = &tos[toindex];
  48.     if (top->selfpc == selfpc) {
  49.     /*
  50.      *    arc at front of chain; usual case.
  51.      */
  52.     top->count++;
  53.     goto done;
  54.     }
  55.     /*
  56.      *    have to go looking down chain for it.
  57.      *    top points to what we are looking at,
  58.      *    prevtop points to previous top.
  59.      *    we know it is not at the head of the chain.
  60.      */
  61.     for (; /* goto done */; ) {
  62.     if (top->link == 0) {
  63.         /*
  64.          *    top is end of the chain and none of the chain
  65.          *    had top->selfpc == selfpc.
  66.          *    so we allocate a new tostruct
  67.          *    and link it to the head of the chain.
  68.          */
  69.         toindex = ++tos[0].link;
  70.         if (toindex >= tolimit) {
  71.         goto overflow;
  72.         }
  73.         top = &tos[toindex];
  74.         top->selfpc = selfpc;
  75.         top->count = 1;
  76.         top->link = *frompcindex;
  77.         *frompcindex = toindex;
  78.         goto done;
  79.     }
  80.     /*
  81.      *    otherwise, check the next arc on the chain.
  82.      */
  83.     prevtop = top;
  84.     top = &tos[top->link];
  85.     if (top->selfpc == selfpc) {
  86.         /*
  87.          *    there it is.
  88.          *    increment its count
  89.          *    move it to the head of the chain.
  90.          */
  91.         top->count++;
  92.         toindex = prevtop->link;
  93.         prevtop->link = top->link;
  94.         top->link = *frompcindex;
  95.         *frompcindex = toindex;
  96.         goto done;
  97.     }
  98.     }
  99. done:
  100.     profiling = 0;
  101.     return;
  102.  
  103. overflow:
  104.     profiling++; /* halt further profiling */
  105. #define    TOLIMIT    "mcount: tos overflow\n"
  106.     write(2, TOLIMIT, sizeof(TOLIMIT));
  107.     return;
  108. }
  109.  
  110.